home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / emulator / bsvc-1.000 / bsvc-1 / bsvc-1.0.4 / samples / Motorola68000 / MatrixMultiply.s < prev    next >
Text File  |  1995-07-26  |  23KB  |  1,018 lines
  1. *
  2. * Interactive Matrix Multiply program for the Motorola 68000
  3. * 
  4.  
  5.     ORG    $1000
  6.  
  7. DUART    EQU    $effc01
  8. MR1A    EQU    0
  9. MR2A    EQU    0
  10. SRA    EQU    2
  11. CRA    EQU    4
  12. CSRA    EQU    2
  13. TBA    EQU    6
  14. RBA    EQU    6
  15. IMR    EQU    10
  16. TBB    EQU    $16
  17. CRB    EQU    $14
  18. MR1B    EQU    $10
  19. MR2B    EQU    $10
  20. SRB    EQU    $12
  21.  
  22.     LEA    DUART,A1
  23.     MOVE.B    #%00010000,CRA(A1)     Reset MR?A pointer
  24.     MOVE.B  #%00100011,MR1A(A1)    8 data bits
  25.     MOVE.B  #%00010111,MR2A(A1)    Normal Mode
  26.     MOVE.B  #%10111011,CSRA(A1)    Set clock to 9600
  27.     MOVE.B  #%00000101,CRA(A1)     Enable Rx and Tx
  28.  
  29.     MOVE.L    #$4000,A7              Setup the stack pointer
  30.  
  31. MAIN:    JSR CLEAR
  32.     JSR TITLE
  33.  
  34.     JSR CLEAR
  35.  
  36.     JSR GETSIZE
  37.  
  38.     MOVE.W    MA_C,D1
  39.     MOVE.W    MA_R,D0
  40.     MOVE.L    #MA_DAT,A0
  41.     MOVE.L    #MA_TI,A1
  42.     JSR    MATIN
  43.  
  44.     MOVE.W    MB_C,D1
  45.     MOVE.W    MB_R,D0
  46.     MOVE.L    #MB_DAT,A0
  47.     MOVE.L    #MB_TI,A1
  48.     JSR MATIN
  49.  
  50.     MOVE.W    MA_R,D0
  51.     MOVE.W    MA_C,D1
  52.     MOVE.W    MB_R,D2
  53.     MOVE.W    MB_C,D3
  54.     MOVE.L    #MA_DAT,A0
  55.     MOVE.L    #MB_DAT,A1
  56.     MOVE.L    #MC_DAT,A2
  57.     JSR    MATMULT
  58.  
  59.     MOVE.W    MA_R,D0
  60.     MOVE.W    MB_C,D1
  61.     MOVE.L    #MC_DAT,A0
  62.     MOVE.L    #MC_TI,A1
  63.     JSR    MATOUT
  64.  
  65.     JMP    EXIT
  66.     NOP
  67.  
  68. MA_R:    DS.W    1
  69. MA_C:    DS.W    1
  70. MB_R:    DS.W    1
  71. MB_C:    DS.W    1
  72. MA_DAT:    DS.W    100                Matrix A Data
  73. MB_DAT:    DS.W    100                             Matrix B Data
  74. MC_DAT: DS.L    100                Matrix C Data (Result)
  75. MA_TI:    DC.B    'Enter Matrix A',0,0
  76. MB_TI:    DC.B    'Enter Matrix B',0,0
  77. MC_TI:    DC.B    'Resulting Matrix C',0,0
  78.  
  79. *
  80. * Input a string
  81. *
  82.  
  83. INPUT:        MOVEM.L    A0-A6/D0-D7,-(A7)
  84.  
  85.         MOVE.L    A0,A5            Save buffer address
  86.         MOVE.L    A1,A6            Save valid string address
  87.                 MOVE.L    D0,D7            Save Max length
  88.         MOVE.L    #0,D1            Current string length
  89.  
  90. IN_LOOP:    JSR    GETC            Get a character
  91.  
  92.         CMPI.B    #$08,D0            Is it backspace
  93.         BEQ    IN_BS
  94.  
  95.         CMPI.B    #$0D,D0            Is it return
  96.         BEQ    IN_RET
  97.  
  98. * Make sure it's a valid character
  99.         MOVE.L    A6,A0
  100. IN_VL:        CMPI.B    #0,(A0)            End of valid string?
  101.         BEQ    IN_INVALID
  102.  
  103.         CMP.B    (A0)+,D0        Is it a valid char?
  104.         BEQ    IN_VALID
  105.  
  106.         BRA    IN_VL            Loop
  107.  
  108. IN_INVALID:    JSR    BELL            Sound Bell
  109.         JMP    IN_LOOP            Get another character
  110.  
  111. IN_VALID:    CMP.W    D7,D1            Have we reach max lenght?
  112.         BNE    IN_VA2            NO!
  113.  
  114.         JSR    BELL
  115.         JMP    IN_LOOP
  116.  
  117. IN_VA2:        MOVE.B    D0,0(A5,D1)        Save character in buffer
  118.         ADDI.W    #1,D1            Inc Lenght counter
  119.         JSR    PUTC            Output character to screen
  120.  
  121.         JMP    IN_LOOP
  122.  
  123.  
  124. IN_BS:        CMPI.W    #0,D1            Make sure no wrap around
  125.         BNE    IN_BOK
  126.  
  127.         JSR    BELL
  128.         JMP    IN_LOOP
  129.  
  130. IN_BOK:        MOVE.B    #$08,D0            BackSpace on screen
  131.         JSR    PUTC
  132.         MOVE.B    #$20,D0
  133.         JSR    PUTC
  134.         MOVE.B    #$08,D0
  135.         JSR    PUTC
  136.  
  137.         SUBI.W    #1,D1            Dec length counter
  138.         JMP    IN_LOOP
  139.  
  140.  
  141. IN_RET:        MOVE.B    #0,0(A5,D1)        Null Terminate
  142.  
  143.         MOVEM.L    (A7)+,A0-A6/D0-D7    Restore REGS
  144.  
  145.         RTS
  146. *
  147. * Routines for performing Polled I/O At the Console Serial Port
  148. *
  149. * By: Bradford W. Mott
  150. *
  151.  
  152. LINEFEED:    EQU    10        * LineFeed Character value
  153. CARR_RETURN:    EQU    13        * Carrage Return character value
  154.  
  155. *
  156. * The character in D0 is transmitted to the CONSOLE ACIA.
  157. * The newline character <LF> is expanded into <LF>/<CR>.
  158. *
  159.  
  160. PUTC:    BTST    #2,SRA+DUART        * Test Transmit data register empty
  161.     BEQ.S    PUTC            * If not keep polling
  162.     MOVE.B    D0,TBA+DUART        * Transmit the character
  163.     CMP.B    #LINEFEED,D0        * Check for LINEFEED
  164.     BNE    PUTEXT
  165.     MOVE.B    #CARR_RETURN,D0        * Load CR into D0
  166.     BRA    PUTC            * Output CR
  167. PUTEXT:    RTS                * Return to calling procedure
  168.  
  169.  
  170. *
  171. * Get a character from the CONSOLE ACIA and return it in D0
  172. *
  173.  
  174. GETC:    BTST    #0,SRA+DUART        * Test Receive data register full
  175.     BEQ.S    GETC            * If not keep polling
  176.     MOVE.B    RBA+DUART,D0        * Read the character
  177.     RTS
  178.  
  179. PRINT:        MOVE.L        D0,-(A7)    *SAVE CURRENT REGS TO STACK
  180. PRLOOP:        MOVE.B        (A0)+,D0    *GET A CHARACTER
  181.         CMP.B        #$00,D0        *IS IT A NULL CHARACTER?
  182.         BEQ        PRNTEND        *IF SO, THEN YOU'RE DONE
  183.         JSR        PUTC        *IF NOT, THEN SEND CHARACTER TO SCREEN
  184.         BRA        PRLOOP        *LOOP UNTIL DONE
  185. PRNTEND:    MOVE.L        (A7)+,D0    *RESTORE REGS
  186.         RTS
  187.  
  188.  
  189. TITLE:        MOVE.L     #SCREEN,A0    *INITIALIZE SCREEN DATA POINTER
  190. TILP:        JSR    PRINT        *PRINT DATA TO SCREEN
  191.         CMPI.B    #$3D,(A0)    *END OF SCREEN DATA?
  192.         BNE    TILP        *IF NOT THEN KEEP PRINTING DATA
  193. TILP1:        JSR    GETC        *IF FINISHED, GET A KEY SRIKE
  194.         CMPI.B    #$0D,D0        *IS IT THE RETURN KEY?
  195.         BNE    TILP1        *IF NOT THEN TRY AGAIN
  196.         JSR    PRINT        *IF SO, THEN PRINT CLEAR SCREEN CHARACTERS
  197.         RTS            *RETURN TO MAIN
  198.  
  199. SCREEN:        DC.B    $1B,'[2J'    
  200.         DC.B    '****',$08,$08,$08,$08,$1B,'[4h'
  201.         DC.B    '                                                                        ****',$1B,'[4l',$1B,'E'
  202.         DC.B    '**',$08,$08,$1B,'[4h'
  203.         DC.B    '                                                                            **',$1B,'[4l',$1B,'E'
  204.         DC.B    '* *',$08,$08,$08,$1B,'[4h'
  205.         DC.B    '                                                                          * *',$1B,'[4l',$1B,'E'
  206.         DC.B    '*',$08,$1B,'[4h'
  207.         DC.B    '                                                                              *',$1B,'[4l',$1B,'E',$1B,'E'
  208.         DC.B    '                      M   M   A   TTTTT RRRR   III  X   X',$1B,'E'
  209.         DC.B      '                      MM MM  A A    T   R   R   I    X X ',$1B,'E'
  210.         DC.B    '                      M M M A   A   T   R   R   I     X  ',$1B,'E'
  211.         DC.B    '                      M   M AAAAA   T   RRRR    I    X X ',$1B,'E'
  212.         DC.B    '                      M   M A   A   T   R  R    I   X   X',$1B,'E'
  213.         DC.B    '                      M   M A   A   T   R   R  III  X   X',$1B,'E'
  214.         DC.B    $1B,'E'
  215.         DC.B    '                M   M U   U L     TTTTT  III  PPPP  L     Y   Y',$1B,'E'
  216.         DC.B    '                MM MM U   U L       T     I   P   P L     Y   Y',$1B,'E'
  217.         DC.B    '                M M M U   U L       T     I   P   P L      Y Y ',$1B,'E'
  218.         DC.B     '                M   M U   U L       T     I   PPPP  L       Y  ',$1B,'E'
  219.         DC.B     '                M   M U   U L       T     I   P     L       Y  ',$1B,'E'
  220.         DC.B    '                M   M  UUU  LLLLL   T    III  P     LLLLL   Y  ',$1B,'E'
  221.         DC.B    $1B,'E'
  222.         DC.B    '*',$08,$1B,'[4h'
  223.         DC.B    '                                                                              *',$1B,'[4l',$1B,'E'
  224.         DC.B    '* *',$08,$08,$08,$1B,'[4h'
  225.         DC.B    '                                                                          * *',$1B,'[4l',$1B,'E'
  226.         DC.B    '**',$08,$08,$1B,'[4h'
  227.         DC.B    '                                                                            **',$1B,'[4l',$1B,'E'
  228.         DC.B    '****',$08,$08,$08,$08,$1B,'[4h'
  229.         DC.B    '                                                                        ****',$1B,'[4l',$1B,'E'
  230.         DC.B    'Press RETURN to Continue... ',$1B,'[4l',$00,$3D,$1B,'[2J',$00,$00
  231.                                                                                 
  232. LTOA:        MOVEM.L        D0-D7/A0-A6,-(A7)
  233.  
  234.         MOVE.B        #$00,-(A0)    *APPEND NULL CHARACTER TO OUTPUT STRING
  235.         MOVE.B        #$00,D2        *SET NEGATIVE FLAG TO INDICATE NON NEGATIVE NUMBER FOR NOW
  236.         MOVE.L        D1,D3        *MOVE HEX OUTPUT (D1) TO HOLDER (D3)
  237.         BPL        LTOALOOP    *IF POSITIVE THEN GO CONVERT
  238.         BNE         LTOA2        *IF ZERO THEN YOUR FINISHED
  239.  
  240.         MOVE.B        #48,-(A0)
  241.         BRA        LTOAEND
  242.  
  243. LTOA2:        NEG.L        D3        *IF NEGATIVE THEN NEGATE
  244.         MOVE.B        #$AA,D7        *SET NEGATIVE FLAG
  245.  
  246. LTOALOOP:    JSR        LDIV        *GO PERFORM LONG DIV BY 10 ON HEX NUMBER
  247.         ADD.W        #$30,D3        *ADD $30 TO REMAINDER
  248.         MOVE.B        D3,-(A0)    *MOVE LSB TO ASCII CHAR STRING POINTER
  249.         MOVE.L        D0,D3        *MOVE RECEIVED QUOTIENT TO D3 TO SEND TO LDIV AGAIN
  250.         TST.L        D0        *IS QUOTIENT EQUAL TO ZERO?
  251.         BNE        LTOALOOP    *IF NOT THEN KEEP CONVERTING
  252.  
  253.         CMPI.B        #$AA,D7        *WAS NEGATIVE FLAG SET?
  254.         BNE        LTOAEND        *NO, GO TO THE END
  255.         MOVE.B        #$2D,-(A0)    *YES, APPEND A NEGATIVE SIGN TO ASCII STRING
  256.  
  257.  
  258. LTOAEND:    MOVEM.L        (A7)+,D0-D7/A0-A6
  259.         RTS                *RETURN
  260.  
  261.  
  262. ATOL:        MOVEM.L        D1-D7/A0-A6,-(A7)    *SAVE PERTINENT REGISTERS
  263.         MOVE.B        #0,D4        *SET NEGATIVE FLAG TO OFF
  264.         MOVE.L        #0,D0        *CLEAR RESULT REGISTER
  265.         MOVE.L        #0,D1        *CLEAR CHARACTER HOLDER
  266.  
  267. ATOLLP1:    MOVE.B        (A0)+,D1    *GET FIRST CHARACTER IN ASCII STRING
  268.         BEQ        ATOLDONE    *IF NULL, THEN YOU'RE FINISHED
  269.         MOVE.L        #VALIDSTR,A1    *SET CHARACTER CHECK POINTER
  270.  
  271. ATOLLP2:    CMP.B        #0,(A1)        *CHECKED FOR ALL VALID CHARACTERS?
  272.         BEQ        ATOLLP1        *IF YES, GET NEXT CHARACTER IN ASCII STRING
  273.         CMP.B        #$2D,D1        *IS IT THE NEGATIVE SIGN?
  274.         BEQ        SETNEG        *IF YES, GO SET NEGATIVE FLAG
  275.         CMP.B        (A1)+,D1    *IS THE CHARACTER VALID?
  276.         BNE        ATOLLP2        *IF NOT, COMPARE TO OTHER VALID CHARACTERS
  277.         
  278.         AND.B        #$0F,D1        *MASK UPPER BITS OF ASCII CHARACTER
  279.         MULU        #10,D0        *BEGIN CONVERSION TO BASE 10
  280.         ADD.L        D1,D0        *ADD NEXT DIGIT IN STRING TO RESULT
  281.         BRA        ATOLLP1        *GET NEXT CHARACTER IN ASCII STRING
  282.  
  283. SETNEG:        MOVE.B        #$FF,D4        *SET NEGATIVE FLAG
  284.         BRA        ATOLLP1        *GET NEXT CHARACTER IN ASCII STRING
  285.  
  286. ATOLDONE:    CMP.B        #$FF,D4        *WAS IT A NEGATIVE NUMBER?
  287.         BNE        ATOLEND        *NO, SKIP TO END
  288.         NEG.L        D0        *YES, NEGATE THE RESULT
  289.  
  290. ATOLEND:    MOVEM.L        (A7)+,D1-D7/A0-A6    *RECALL PERTINENT REGISTERS
  291.         RTS                *RETURN RESULT
  292.  
  293. VALIDSTR:    DC.B        '1234567890',0,0
  294.  
  295. LDIV:        MOVE.L        D3,D0        *STORE IN D0 FOR NOW
  296.         CLR.W        D3        *CLEAR LOWER WORD OF DIVIDEND
  297.         SWAP        D3        *MOVE UPPER WORD TO LOWER POSITION
  298.         SWAP        D0        *SWAP THE HOLDER
  299.         DIVU        #$A,D3        *PERFORM CONVERSION DIVISION
  300.         MOVE.W        D3,D0        *MOVE MSW QUOTIENT TO D0
  301.         SWAP        D0        *SWAP IT INTO MSW POSITION
  302.         MOVE.W        D0,D3        *MOVE LSW INTO DIVIDEND
  303.         DIVU        #$A,D3        *PERFORM CONVERSION DIVISION
  304.         MOVE.W        D3,D0        *MOVE LSW QUOTIENT TO D0
  305.         CLR.W        D3        *CLEARS LSW QUOTIENT FROM D3
  306.         SWAP         D3        *SWAPS TOTAL REMAINDER TO LSW OF D3
  307.         RTS                *RETURNS BIG QUOTIENT (D0), REMAINDER (D3)*
  308. * Routines to control the Terminal Display
  309. *
  310. * By: Bradford W. Mott
  311. *
  312.  
  313.  
  314. BELL_CODE:    EQU    07
  315.  
  316.  
  317. *
  318. * This routine sounds the terminal bell
  319. *
  320.  
  321. BELL:    MOVE.L    D0,-(A7)        * Save D0 on stack
  322.     MOVE.L    #BELL_CODE,D0        * Get the BELL character
  323.     JSR    PUTC            * Transmit it to the TERMINAL
  324.     MOVE.L    (A7)+,D0        * Restore D0
  325.     RTS                * Return to calling procedure
  326.  
  327.  
  328. *
  329. * This routine clears the terminal display and homes the cursor
  330. *
  331.  
  332. CLEAR:    MOVEM.L    D0/A0,-(A7)        * Save A0&D0 on stack
  333.     MOVE.L    #CLRSTR,A0        * Load address of clear screen string
  334. CLLOOP:    MOVE.B    (A0)+,D0        * Get a character
  335.     BEQ    CLEXT            * EXIT on NULL
  336.     JSR    PUTC            * Put character to display
  337.     BRA    CLLOOP            * Loop
  338. CLEXT:    MOVEM.L    (A7)+,D0/A0        * Restore A0&D0
  339.     RTS                * Return to calling procedure
  340.  
  341. CLRSTR:    DC.B 27,'[;H',27,'[2J',0,0    * Clear Screen code for VT100
  342.  
  343.  
  344.  
  345. *
  346. * This routine moves the display's cursor to the X/Y coordinates
  347. * specified in the D0 & D1 registers (X=D0,Y=D1)
  348. *
  349.  
  350. POSITION:    MOVEM.L    D0-D7/A0-A6,-(A7)    * Save D0-D1 & A0 on stack
  351.  
  352.         ANDI.L    #255,D0        * Clear the unused parts of 
  353.         ANDI.L    #255,D1        * data register
  354.  
  355.         MOVE.L  #POSSTR+2,A0    * Address of row substring
  356.         DIVU    #10,D1        * Let's convert row number to ASCII
  357.         ADDI.B    #48,D1
  358.         MOVE.B    D1,(A0)+    * Put in POSSTR
  359.         SWAP    D1
  360.         ADDI.B    #48,D1
  361.         MOVE.B    D1,(A0)        * Put in POSSTR
  362.  
  363.         MOVE.B    #48,POSSTR+5
  364.         CMPI.W    #100,D0
  365.         BLT    POS2
  366.  
  367.         SUBI.W    #100,D0
  368.         MOVE.B  #49,POSSTR+5
  369.  
  370. POS2:        MOVE.L    #POSSTR+6,A0    * Address of col substring
  371.         DIVU    #10,D0        * Let's convert column number to ASCII
  372.         ADDI.B    #48,D0
  373.         MOVE.B    D0,(A0)+    * Put in POSSTR
  374.         SWAP    D0
  375.         ADDI.B    #48,D0
  376.         MOVE.B    D0,(A0)        * Put in POSSTR
  377.  
  378.         MOVE.L    #POSSTR,A0    * Get addr of POSITION string
  379. POSLOOP:    MOVE.B    (A0)+,D0    * Get a character
  380.         BEQ    POSEXT        * Exit on NULL
  381.         JSR     PUTC        * Send to the terminal
  382.         BRA    POSLOOP        * Loop
  383.     
  384. POSEXT:        MOVEM.L    (A7)+,D0-D7/A0-A6    * Restore registers
  385.         RTS            * Return to calling procedure
  386.  
  387.         DC.W    0,0,0,0
  388. POSSTR:     DC.B 27,'[00;000;H',0        * Position Cursor code for VT100
  389.         DC.W    0,0,0,0
  390.  
  391.  
  392.  
  393.  
  394.  
  395. *
  396. * This routine gets the sizes of the two matrices to multiply
  397. *
  398.  
  399. GETSIZE:    MOVEM.L    D0-D7/A0-A6,-(SP)
  400.  
  401.         JSR CLEAR
  402.  
  403.         MOVE.L    #GS_TIT,A0        Print title
  404.         JSR    PRINT
  405.  
  406.  
  407. GS_GAC:        MOVE.L    #GS_CA,A0
  408.         JSR    PRINT
  409.  
  410.         MOVE.L    #GS_VALID,A1        Get number of columns
  411.         MOVE.L    #GS_BUFFER,A0
  412.         MOVE.W    #2,D0
  413.         JSR    INPUT
  414.  
  415.         MOVE.L    #GS_BUFFER,A0
  416.         JSR    ATOL
  417.         MOVE.W    D0,MA_C
  418.  
  419.         CMPI.W    #10,D0
  420.         BGT    GS_ACA
  421.         CMPI.W    #1,D0
  422.         BLT    GS_ACA
  423.         BRA    GS_GAR
  424.  
  425. GS_ACA:        MOVE.L    #GS_ERROR,A0
  426.         JSR    PRINT
  427.         JMP    GS_GAC
  428.  
  429.  
  430.  
  431. GS_GAR:        MOVE.L    #GS_RA,A0
  432.         JSR    PRINT
  433.  
  434.         MOVE.L    #GS_VALID,A1        Get number of columns
  435.         MOVE.L    #GS_BUFFER,A0
  436.         MOVE.W    #2,D0
  437.         JSR    INPUT
  438.  
  439.         MOVE.L    #GS_BUFFER,A0
  440.         JSR    ATOL
  441.         MOVE.W    D0,MA_R
  442.  
  443.         CMPI.W    #10,D0
  444.         BGT    GS_ARA
  445.         CMPI.W    #1,D0
  446.         BLT    GS_ARA
  447.         BRA    GS_GBC
  448.  
  449. GS_ARA:        MOVE.L    #GS_ERROR,A0
  450.         JSR    PRINT
  451.         JMP    GS_GAR
  452.  
  453.  
  454.  
  455. GS_GBC:        MOVE.L    #GS_CB,A0
  456.         JSR     PRINT
  457.  
  458.         MOVE.L    #GS_VALID,A1        Get number of columns
  459.         MOVE.L    #GS_BUFFER,A0
  460.         MOVE.W    #2,D0
  461.         JSR    INPUT
  462.  
  463.         MOVE.L    #GS_BUFFER,A0
  464.         JSR    ATOL
  465.         MOVE.W    D0,MB_C
  466.  
  467.         CMPI.W    #10,D0
  468.         BGT    GS_BCA
  469.         CMPI.W    #1,D0
  470.         BLT    GS_BCA
  471.         BRA    GS_GBR
  472.  
  473. GS_BCA:        MOVE.L    #GS_ERROR,A0
  474.         JSR    PRINT
  475.         JMP    GS_GBC
  476.  
  477.  
  478.  
  479. GS_GBR:        MOVE.L    #GS_RB,A0
  480.         JSR     PRINT
  481.  
  482.         MOVE.L    #GS_VALID,A1        Get number of columns
  483.         MOVE.L    #GS_BUFFER,A0
  484.         MOVE.W    #2,D0
  485.         JSR    INPUT
  486.  
  487.         MOVE.L    #GS_BUFFER,A0
  488.         JSR    ATOL
  489.         MOVE.W    D0,MB_R
  490.  
  491.         CMPI.W    #10,D0
  492.         BGT    GS_BRA
  493.         CMPI.W    #1,D0
  494.         BLT    GS_BRA
  495.         BRA    GS_TEST
  496.  
  497. GS_BRA:        MOVE.L    #GS_ERROR,A0
  498.         JSR    PRINT
  499.         JMP    GS_GBR
  500.  
  501.  
  502. GS_TEST:    MOVE.W    MA_C,D0
  503.         CMP.W    MB_R,D0
  504.         BEQ    GS_OK
  505.  
  506.         MOVE.L    #GS_BERR,A0
  507.         JSR    PRINT
  508.         JMP    GS_GAC
  509.  
  510. GS_OK:        MOVEM.L    (A7)+,D0-D7/A0-A6
  511.         RTS
  512.  
  513.  
  514. GS_TIT:        DC.B    ' Matrix Multiply ',10
  515.         DC.B    '-----------------',10,10
  516.         DC.B    'Please enter the sizes of the matrices to multiply.',10,10,0,0
  517.  
  518. GS_CA:        DC.B    10,'Columns in matrix A : ',0
  519. GS_RA:        DC.B    10,'Rows in matrix A    : ',0
  520. GS_CB:        DC.B    10,10,'Columns in matrix B : ',0,0
  521. GS_RB:        DC.B    10,'Rows in matrix B    : ',0
  522.  
  523. GS_VALID:    DC.B    '0123456789',0,0
  524. GS_BUFFER:    DC.B    0,0,0,0,0,0
  525.  
  526. GS_ERROR:    DC.B    10,'Invalid size!!!',10,0    
  527. GS_BERR:    DC.B    10,'Matrix sizes incompatible!!!!!',10,0,0
  528. *
  529. * This routine multiplies two matrices and stores the resulting
  530. * matrix. ( C=AB )
  531. *
  532. * A0 = Matrix A
  533. * A1 = Matrix B
  534. * A2 = Matrix C
  535. *
  536. * D0 = Matrix A number of rows (i)
  537. * D1 = Matrix A number of columns
  538. * D2 = Matrix B number of rows
  539. * D3 = Matrix B number of columns (j)
  540. *
  541.  
  542. MATMULT:
  543.     MOVEM.L    D0-D7/A0-A6,-(A7)
  544.  
  545.     MOVE.W    D3,B_COLS        Save Columns in C
  546.  
  547. I_LOOP:    MOVE.W    B_COLS,D3
  548.     SUBI.W    #1,D0
  549.     BMI    MATFIN
  550.  
  551. J_LOOP:    MOVE.L    #0,SUM
  552.     MOVE.W    D1,D4        T Counter
  553.     SUBI.W    #1,D4
  554.  
  555.     SUB.W    #1,D3
  556.     BMI    I_LOOP
  557.  
  558. T_LOOP:    MOVE.W    D1,D5        Num Columns in A
  559.     MULU    D0,D5        I * Columns in A
  560.     ADD.W    D4,D5        + T
  561.     MULU    #2,D5        Words
  562.     MOVEQ    #0,D6
  563.     MOVE.W    (A0,D5),D6    Get A(i,t)
  564.  
  565.     MOVE.W    B_COLS,D5        Num Columns in B
  566.     MULU    D4,D5        T * Columns in B
  567.     ADD.W    D3,D5        + J
  568.     MULU    #2,D5
  569.     MOVEQ    #0,D7
  570.     MOVE.W    (A1,D5),D7    Get B(t,j)
  571.  
  572.     MULS    D6,D7        A(i,t)*B(t,j)
  573.     ADD.L    D7,SUM        add to running Sum
  574.  
  575.     SUBI.W    #1,D4
  576.     BPL    T_LOOP
  577.  
  578.     MOVE.W    B_COLS,D5    Num Columns in C
  579.     MULU    D0,D5        I * Num Columns in C
  580.     ADD.W    D3,D5        + J
  581.     MULU    #4,D5
  582.     MOVE.L    SUM,(A2,D5)    Store C(i,j)
  583.  
  584.     BRA    J_LOOP
  585.     BRA    I_LOOP
  586.  
  587. MATFIN:    MOVEM.L    (A7)+,D0-D7/A0-A6
  588.     RTS
  589.  
  590.  
  591. SUM:    DC.L    $1
  592. B_COLS:    DC.W    $1
  593. *
  594. *     MATOUT
  595. **
  596. * D0 contains the number of columns
  597. * D1 contains the number of rows
  598. *
  599. * A0 contains a pointer to a buffer to store matrix elements in
  600. * A1 contains a pointer to the a title string
  601. *
  602. * By: Bradford W. Mott
  603. *
  604.  
  605.  
  606. MATOUT:        MOVEM.L    A0-A6/D0-D7,-(A7)    Save registers on stack
  607.  
  608.         MOVE.L    A0,MO_DATA        Store buffer address
  609.         MOVE.W    D0,MO_ROW        Store num of rows
  610.         MOVE.W    D1,MO_COL        Store num of columns
  611.  
  612.  
  613.         JSR    CLEAR            Clear the display
  614.  
  615.         MOVE.L    #MO_32ON,A0        Turn 132 mode on
  616.         JSR    PRINT
  617.  
  618.         MOVE.W    #57,D0            X position of cursor
  619.         MOVE.W    #2,D1            Y position of cursor
  620.         JSR    POSITION        Position the Cursor
  621.  
  622.         MOVE.L    A1,A0            Print the Title String
  623.         JSR    PRINT
  624.  
  625.  
  626.         MOVE.L    #MO_Y,A0        Pointer to Y position array
  627.         MOVEQ    #0,D0            Clear LCV (Loop Control Var)
  628.  
  629. MO_L1:        MOVE.W    #20,D1            Calculate Y position
  630.         SUB.W    MO_ROW,D1
  631.         DIVU    #2,D1
  632.         ADD.W    D0,D1            (20-row)/2+counter
  633.         MOVE.B    D1,0(A0,D0)        Store in array
  634.  
  635.         ADDQ.W    #1,D0
  636.         CMP.W    MO_ROW,D0
  637.         BNE    MO_L1
  638.  
  639.  
  640.         MOVE.L    #MO_X,A0        Pointer to X position array
  641.         MOVEQ    #0,D0            Clear LCV (Loop Control Var)
  642.  
  643. MO_L2:        MOVE.W    #132,D1            Calculate X position
  644.         MOVE.W  MO_COL,D2
  645.         MULU    #10,D2
  646.         SUB.W    D2,D1
  647.         DIVU    #2,D1
  648.         MOVE.W    D0,D2
  649.         MULU    #10,D2
  650.         ADD.W    D2,D1            (132-col*10)/2+counter*10
  651.         MOVE.B    D1,0(A0,D0)        Store in array
  652.  
  653.         ADDQ.W    #1,D0
  654.         CMP.W    MO_COL,D0
  655.         BNE    MO_L2
  656.  
  657.  
  658. * Draw the Matrix outline
  659.  
  660.         MOVE.L    #MO_Y,A0        Pointer to Y position array
  661.         MOVEQ    #0,D7            Clear LCV (Loop Control Var)
  662.  
  663. MO_L3:        MOVE.W    #132,D0            Calculate X position
  664.         MOVE.W    MO_COL,D1
  665.         MULU    #10,D1
  666.         SUB.W    D1,D0
  667.         DIVU    #2,D0
  668.         SUBI.W    #2,D0            D0=(132-col*10)/2-2
  669.  
  670.         MOVE.B    0(A0,D7),D1        Get Y Position
  671.  
  672.         JSR    POSITION        Position Cursor
  673.         MOVE.B    #$7C,D0            the "|" character
  674.         JSR    PUTC
  675.  
  676.  
  677.         MOVE.W    #132,D0            Calculate X position
  678.         MOVE.W    MO_COL,D1
  679.         MULU    #10,D1
  680.         SUB.W    D1,D0
  681.         DIVU    #2,D0
  682.         ADD.W    D1,D0            D0=(132-col*10)/2+col*10
  683.  
  684.         MOVE.B    0(A0,D7),D1        Get Y Position
  685.  
  686.         JSR    POSITION        Position Cursor
  687.         MOVE.B    #$7C,D0            the "|" character
  688.         JSR    PUTC
  689.  
  690.         ADDQ.W    #1,D7
  691.         CMP.W    MO_ROW,D7
  692.         BNE    MO_L3
  693.  
  694. * Get the data for each element.
  695.  
  696.         MOVEQ    #0,D7            LCV for row
  697.         MOVE.L    #MO_X,A3
  698.         MOVE.L    #MO_Y,A4
  699.  
  700. MO_L4:        MOVEQ    #0,D6            LCV for column
  701.  
  702. MO_L5:        MOVE.B    0(A3,D6),D0
  703.         MOVE.B    0(A4,D7),D1
  704.         JSR    POSITION
  705.  
  706.  
  707.         MOVE.L    #$20202020,MO_OUT      Set output to all spaces
  708.         MOVE.L    #$20202020,MO_OUT+4
  709.         MOVE.L    #$20200000,MO_OUT+8
  710.  
  711.         MOVE.L    MO_DATA,A0
  712.         MOVE.W    MO_COL,D0
  713.         MULU    D7,D0            D0=row*col
  714.         MULU    #4,D0            *4
  715.  
  716.         MOVE.W    D6,D1
  717.         MULU    #4,D1
  718.         ADD.W    D1,D0
  719.  
  720.         MOVE.L    0(A0,D0),D1        Store entry in Matrix Buffer
  721.  
  722.         MOVE.L    #MO_OUT+10,A0
  723.         JSR    LTOA
  724.  
  725.         MOVE.L    #MO_OUT,A0
  726.         JSR    PRINT
  727.  
  728.         ADDQ.W    #1,D6
  729.         CMP.W    MO_COL,D6
  730.         BNE    MO_L5
  731.  
  732.         ADDQ.W    #1,D7
  733.         CMP.W    MO_ROW,D7
  734.         BNE    MO_L4
  735.  
  736.  
  737. * PRINT PROMPT
  738.         MOVE.W    #0,D0
  739.         MOVE.W    #22,D1
  740.         JSR    POSITION
  741.         MOVE.L    #MO_PROMPT,A0
  742.         JSR    PRINT
  743.  
  744. MO_LKEY:    JSR    GETC
  745.         CMPI.B    #13,D0
  746.         BNE    MO_LKEY    
  747.  
  748. * Go back to 80 column mode
  749.         MOVE.L    #MO_32OFF,A0
  750.         JSR    PRINT
  751.  
  752. * Return to calling routine
  753.  
  754.         MOVEM.L    (A7)+,A0-A6/D0-D7    Restore Registers
  755.  
  756.         RTS                Return to caller
  757.  
  758.  
  759. MO_OUT:         DC.B    '-1000',0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  760. MO_PROMPT:      DC.B    'Press Return Key...',0
  761. MO_HOFF:        DC.B    27,'[0m',0,0
  762. MO_SSR:         DC.B    27,'[20;23r',0,0
  763. MO_SRR:         DC.B    27,'[0;24r',0
  764. MO_Y:           DC.B    0,0,0,0,0,0,0,0,0,0,0,0
  765. MO_X:           DC.B    0,0,0,0,0,0,0,0,0,0,0,0
  766. MO_DATA:        DC.L    0
  767. MO_ROW:         DC.W    0
  768. MO_COL:         DC.W    0
  769. MO_32ON:    DC.B    27,'[?3h',0
  770. MO_32OFF:    DC.B    27,'[?3l',0
  771.  
  772.  
  773. *
  774. *     MATIN
  775. *
  776. * This routine allows the user to enter the elements of a matrix
  777. *
  778. * D0 contains the number of columns
  779. * D1 contains the number of rows
  780. *
  781. * A0 contains a pointer to a buffer to store matrix elements in
  782. * A1 contains a pointer to the a title string
  783. *
  784. * By: Bradford W. Mott
  785. *
  786.  
  787.  
  788. MATIN:        MOVEM.L    A0-A6/D0-D7,-(A7)    Save registers on stack
  789.  
  790.         MOVE.L    A0,MI_DATA        Store buffer address
  791.         MOVE.W    D0,MI_ROW        Store num of rows
  792.         MOVE.W    D1,MI_COL        Store num of columns
  793.  
  794.         JSR    CLEAR            Clear the display
  795.  
  796.         MOVE.W    #33,D0            X position of cursor
  797.         MOVE.W    #2,D1            Y position of cursor
  798.         JSR    POSITION        Position the Cursor
  799.  
  800.         MOVE.L    A1,A0            Print the Title String
  801.         JSR    PRINT
  802.  
  803.  
  804.         MOVE.L    #MI_Y,A0        Pointer to Y position array
  805.         MOVEQ    #0,D0            Clear LCV (Loop Control Var)
  806.  
  807. MI_L1:        MOVE.W    #20,D1            Calculate Y position
  808.         SUB.W    MI_ROW,D1
  809.         DIVU    #2,D1
  810.         ADD.W    D0,D1            (20-row)/2+counter
  811.         MOVE.B    D1,0(A0,D0)        Store in array
  812.  
  813.         ADDQ.W    #1,D0
  814.         CMP.W    MI_ROW,D0
  815.         BNE    MI_L1
  816.  
  817.  
  818.         MOVE.L    #MI_X,A0        Pointer to X position array
  819.         MOVEQ    #0,D0            Clear LCV (Loop Control Var)
  820.  
  821. MI_L2:        MOVE.W    #80,D1            Calculate X position
  822.         MOVE.W  MI_COL,D2
  823.         MULU    #6,D2
  824.         SUB.W    D2,D1
  825.         DIVU    #2,D1
  826.         MOVE.W    D0,D2
  827.         MULU    #6,D2
  828.         ADD.W    D2,D1            (80-col*6)/2+counter*6
  829.         MOVE.B    D1,0(A0,D0)        Store in array
  830.  
  831.         ADDQ.W    #1,D0
  832.         CMP.W    MI_COL,D0
  833.         BNE    MI_L2
  834.  
  835.  
  836. * Draw the Matrix outline
  837.  
  838.         MOVE.L    #MI_Y,A0        Pointer to Y position array
  839.         MOVEQ    #0,D7            Clear LCV (Loop Control Var)
  840.  
  841. MI_L3:        MOVE.W    #80,D0            Calculate X position
  842.         MOVE.W    MI_COL,D1
  843.         MULU    #6,D1
  844.         SUB.W    D1,D0
  845.         DIVU    #2,D0
  846.         SUBI.W    #2,D0            D0=(80-col*6)/2-2
  847.  
  848.         MOVE.B    0(A0,D7),D1        Get Y Position
  849.  
  850.         JSR    POSITION        Position Cursor
  851.         MOVE.B    #$7C,D0            the "|" character
  852.         JSR    PUTC
  853.  
  854.  
  855.         MOVE.W    #80,D0            Calculate X position
  856.         MOVE.W    MI_COL,D1
  857.         MULU    #6,D1
  858.         SUB.W    D1,D0
  859.         DIVU    #2,D0
  860.         ADD.W    D1,D0            D0=(80-col*6)/2+col*6
  861.  
  862.         MOVE.B    0(A0,D7),D1        Get Y Position
  863.  
  864.         JSR    POSITION        Position Cursor
  865.         MOVE.B    #$7C,D0            the "|" character
  866.         JSR    PUTC
  867.  
  868.         ADDQ.W    #1,D7
  869.         CMP.W    MI_ROW,D7
  870.         BNE    MI_L3
  871.  
  872.  
  873.  
  874. * Set the Display scrolling region
  875.  
  876.         MOVE.L    #MI_SSR,A0        Addr of string
  877.         JSR    PRINT
  878.  
  879.  
  880. * Get the data for each element.
  881.  
  882.         MOVEQ    #0,D7            LCV for row
  883.         MOVE.L    #MI_X,A3
  884.         MOVE.L    #MI_Y,A4
  885.  
  886. MI_L4:        MOVEQ    #0,D6            LCV for column
  887.  
  888. MI_L5:        MOVE.B    0(A3,D6),D0
  889.         MOVE.B    0(A4,D7),D1
  890.         JSR    POSITION
  891.  
  892.         MOVE.L    #MI_HON,A0        Turn Highlight on
  893.         JSR    PRINT
  894.  
  895.         MOVE.L    #MI_SPACE,A0        Print Space
  896.         JSR    PRINT
  897.  
  898.         MOVE.L    #MI_HOFF,A0        Turn Highlight off
  899.         JSR    PRINT
  900.  
  901.         MOVE.W    #0,D0
  902.         MOVE.W    #23,D1
  903.         JSR    POSITION
  904.  
  905. MI_AGAIN:    MOVE.L    #MI_PROMPT,A0        Print prompt
  906.         JSR    PRINT
  907.  
  908.         MOVE.L    #MI_INPUT,A0
  909.         MOVE.L    #MI_VALID,A1
  910.         MOVE.L    #5,D0
  911.         JSR    INPUT            INPUT the number
  912.  
  913.         MOVE.L    #10,D0            NEWLINE
  914.         JSR    PUTC
  915.  
  916.         MOVE.L    #MI_INPUT,A0
  917.         JSR    ATOL            Convert ASCII to Long INT
  918.         MOVE.L    D0,MI_INN
  919.  
  920.         CMPI.W    #1000,D0        Make sure number is right
  921.         BGT    MI_ER            size
  922.         CMPI.W    #-1000,D0
  923.         BLT    MI_ER
  924.         
  925.         BRA    MI_NER
  926.  
  927. MI_ER:        MOVE.L    #MI_ERROR,A0        Print Error Message
  928.         JSR    PRINT
  929.         JMP    MI_AGAIN        Try Again!!!
  930.  
  931. MI_NER:        MOVE.L    #$20202020,MI_OUT      Set output to all spaces
  932.         MOVE.L    #$20000000,MI_OUT+4
  933.         MOVE.L    #MI_OUT+6,A0
  934.         MOVEQ    #0,D1
  935.         MOVE.L    MI_INN,D1
  936.         JSR    LTOA
  937.  
  938.                MOVE.B 0(A3,D6),D0
  939.         MOVE.B 0(A4,D7),D1
  940.         JSR    POSITION
  941.  
  942.         MOVE.L    #MI_OUT,A0        Print Entry
  943.         JSR    PRINT
  944.  
  945.         MOVE.L    MI_DATA,A0
  946.         MOVE.W    MI_COL,D0
  947.         MULU    D7,D0            D0=row*col
  948.         MULU    #2,D0            *2
  949.  
  950.         MOVE.W    D6,D1
  951.         MULU    #2,D1
  952.         ADD.W    D1,D0
  953.  
  954.         MOVE.L    MI_INN+2,0(A0,D0)        Store entry in Matrix Buffer
  955.  
  956.         ADDQ.W    #1,D6
  957.         CMP.W    MI_COL,D6
  958.         BNE    MI_L5
  959.  
  960.         ADDQ.W    #1,D7
  961.         CMP.W    MI_ROW,D7
  962.         BNE    MI_L4
  963.  
  964. * Reset the terminal's scrolling region
  965.  
  966.         MOVE.L    #MI_SRR,A0
  967.         JSR    PRINT
  968.  
  969.  
  970. * Return to calling routine
  971.  
  972.         MOVEM.L    (A7)+,A0-A6/D0-D7    Restore Registers
  973.  
  974.         RTS                Return to caller
  975.  
  976.  
  977. MI_INN:         DC.L   0,0,0,0,0
  978. MI_OUT:         DC.B    '-1000',0,0,0,0,0,0,0,0,0
  979. MI_VALID:       DC.B    '0123456789-',0
  980. MI_INPUT:       DC.B    0,0,0,0,0,0,0,0,0,0,0,0,0,0
  981. MI_PROMPT:      DC.B    'Enter Element: ',0
  982. MI_ERROR:       DC.B    '*** Problem with entry!!!!',10,10,0,0
  983. MI_SPACE:       DC.B    '     ',0,0
  984. MI_HON:         DC.B    27,'[5;7m',0,0
  985. MI_HOFF:        DC.B    27,'[0m',0,0
  986. MI_SSR:         DC.B    27,'[20;23r',0,0
  987. MI_SRR:         DC.B    27,'[0;24r',0
  988. MI_Y:           DC.B    0,0,0,0,0,0,0,0,0,0,0,0
  989. MI_X:           DC.B    0,0,0,0,0,0,0,0,0,0,0,0
  990. MI_DATA:        DC.L    0
  991. MI_ROW:         DC.W    0
  992. MI_COL:         DC.W    0
  993.  
  994.  
  995. EXIT:        MOVE.L        #QUITMSG,A0    *INITIALIZE QUIT PROMPT
  996.         JSR         PRINT        *PRINT QUIT PROMPT
  997.         JSR        GETC        *GET RESPONSE
  998.         CMP.B        #$59,D0        *A VALID CHARACTER?
  999.         BEQ        QSTRT        *YES, START OVER
  1000.         CMP.B        #$79,D0        *A VALID CHARACTER?
  1001.         BEQ        QSTRT        *YES, START OVER
  1002.         CMP.B        #$4E,D0        *A VALID CHARACTER?
  1003.         BEQ        QFIN        *NO, QUIT PROGRAM
  1004.         CMP.B        #$6E,D0        *A VALID CHARACTER?
  1005.         BEQ        QFIN        *NO, QUIT PROGRAM
  1006.         BRA        EXIT        *NOT A VALID CHARACTER
  1007.  
  1008. QSTRT:        BRA        MAIN        *RE-EXECUTE MAIN PROGRAM
  1009.  
  1010. QFIN:        MOVE.L        #ENDMSG,A0    *INITIALIZE FINAL MESSAGE
  1011.         JSR        PRINT        *PRINT FINAL MESSAGE
  1012. NOMOE:        BRA        NOMOE        *INFINITE LOOP
  1013.  
  1014. QUITMSG:    DC.B        10,'Multiply Another Set? <Y,y,N,n>...',0,0
  1015. ENDMSG:        DC.B        10,10,'THANK YOU, GOODBYE..',0
  1016.  
  1017.  
  1018.